/*
 * Copyright 2017 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef GrTextureEffect_DEFINED
#define GrTextureEffect_DEFINED

#include "include/core/SkMatrix.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkSamplingOptions.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrFragmentProcessor.h"
#include "src/gpu/ganesh/GrProcessorUnitTest.h"
#include "src/gpu/ganesh/GrSamplerState.h"
#include "src/gpu/ganesh/GrSurfaceProxyView.h"
#include "src/gpu/ganesh/GrTextureProxy.h"
#include "src/gpu/ganesh/glsl/GrGLSLShaderBuilder.h"

#include <cstdint>
#include <memory>

class GrGLSLProgramDataManager;
class GrTexture;
enum SkAlphaType : int;
namespace skgpu {
class KeyBuilder;
}
struct GrShaderCaps;

class GrTextureEffect : public GrFragmentProcessor {
public:
    inline static constexpr float kDefaultBorder[4] = {0};

    // An extra inset amount to apply to subset clamp boundaries to ensure clamped coordinates will
    // access texel (i-1) to i instead of i to (i+1), even if the weights should mean the clamped
    // color is still equal to texel i's value.
#if defined(SK_USE_SAFE_INSET_FOR_TEXTURE_SAMPLING)
    inline static constexpr float kInsetEpsilon = 0.0001f;
#else
    // A value of 0 means that coordinates for linear filtering will be clamped to exactly 1/2px
    // inset from the defined data boundary (for approx-fit textures that don't fill to the HW
    // boundaries). For bottom/right edges this can then access the row or column outside of the
    // defined data. The filtering weight should be 0, which should be safe for non-floating-point
    // color types, and not have any impact on the clamped sample. In practice, devices with lower
    // precision texture coordinates may not actually evaluate with a weight of 0, and it is
    // caught by Swiftshader+MSAN.
    inline static constexpr float kInsetEpsilon = 0.f;
#endif

    inline static constexpr float kLinearInset = 0.5f + kInsetEpsilon;

    /* * Make from a filter. The sampler will be configured with clamp mode. */
    static std::unique_ptr<GrFragmentProcessor> Make(GrSurfaceProxyView, SkAlphaType, const SkMatrix & = SkMatrix::I(),
        GrSamplerState::Filter = GrSamplerState::Filter::kNearest,
        GrSamplerState::MipmapMode mipmapMode = GrSamplerState::MipmapMode::kNone);

    /* *
     * Make from a full GrSamplerState. Caps are required to determine support for kClampToBorder.
     * This will be emulated in the shader if there is no hardware support.
     */
    static std::unique_ptr<GrFragmentProcessor> Make(GrSurfaceProxyView, SkAlphaType, const SkMatrix &, GrSamplerState,
        const GrCaps &caps, const float border[4] = kDefaultBorder);

    /* *
     * Makes a texture effect that samples a subset of a texture. The wrap modes of the
     * GrSampleState are applied to the subset in the shader rather than using HW samplers.
     * The 'subset' parameter specifies the texels in the base level. The shader code will
     * avoid allowing linear filtering to read outside the texel window. However, if MIP
     * filtering is used and a shader invocation reads from a level other than the base
     * then it may read texel values that were computed from in part from base level texels
     * outside the window. More specifically, we treat the MIP map case exactly like the
     * linear case in terms of how the final texture coords are computed. If
     * alwaysUseShaderTileMode is true then MakeSubset won't attempt to use HW wrap modes if the
     * subset contains the entire texture.
     */
    static std::unique_ptr<GrFragmentProcessor> MakeSubset(GrSurfaceProxyView, SkAlphaType, const SkMatrix &,
        GrSamplerState, const SkRect &subset, const GrCaps &caps, const float border[4] = kDefaultBorder,
        bool alwaysUseShaderTileMode = false);

    /* *
     * The same as above but also takes a 'domain' that specifies any known limit on the post-
     * matrix texture coords that will be used to sample the texture. Specifying this requires
     * knowledge of how this effect will be nested into a paint, the local coords used with the
     * draw, etc. It is only used to attempt to optimize away the shader subset calculations.
     */
    static std::unique_ptr<GrFragmentProcessor> MakeSubset(GrSurfaceProxyView, SkAlphaType, const SkMatrix &,
        GrSamplerState, const SkRect &subset, const SkRect &domain, const GrCaps &caps,
        const float border[4] = kDefaultBorder);

    /* *
     * Like MakeSubset() but always uses kLinear filtering. MakeSubset() uses the subset rect
     * dimensions to determine the period of the wrap mode (for repeat and mirror). Once it computes
     * the wrapped texture coordinate inside subset rect it further clamps it to a 0.5 inset rect of
     * subset. When subset is an integer rectangle this clamping avoids the hw linear filtering from
     * reading texels just outside the subset rect. This factory allows a custom inset clamping
     * distance rather than 0.5, allowing those neighboring texels to influence the linear filtering
     * sample result. If there is a known restriction on the post-matrix texture coords it can be
     * specified using domain.
     */
    static std::unique_ptr<GrFragmentProcessor> MakeCustomLinearFilterInset(GrSurfaceProxyView, SkAlphaType,
        const SkMatrix &, GrSamplerState::WrapMode wx, GrSamplerState::WrapMode wy, const SkRect &subset,
        const SkRect *domain, SkVector inset, const GrCaps &caps, const float border[4] = kDefaultBorder);

    std::unique_ptr<GrFragmentProcessor> clone() const override;

    const char *name() const override
    {
        return "TextureEffect";
    }

    GrSamplerState samplerState() const
    {
        return fSamplerState;
    }

    GrTexture *texture() const
    {
        return fView.asTextureProxy()->peekTexture();
    }

    const GrSurfaceProxyView &view() const
    {
        return fView;
    }

    // Gets a matrix that is concat'ed by wrapping GrMatrixEffect that handles y-flip and coord
    // normalization if required. This matrix is not always known when we make the GrTextureEffect
    // because of fully-lazy proxies. Hence, this method  exists to allow this concat to happen
    // after proxy instantiation with coordination from GrMatrixEffect.
    SkMatrix coordAdjustmentMatrix() const;

    class Impl : public ProgramImpl {
    public:
        void emitCode(EmitArgs &) override;

        void setSamplerHandle(GrGLSLShaderBuilder::SamplerHandle handle)
        {
            fSamplerHandle = handle;
        }

    private:
        void onSetData(const GrGLSLProgramDataManager &, const GrFragmentProcessor &) override;

        UniformHandle fSubsetUni;
        UniformHandle fClampUni;
        UniformHandle fIDimsUni;
        UniformHandle fBorderUni;
        GrGLSLShaderBuilder::SamplerHandle fSamplerHandle;
    };

private:
    struct Sampling;

    /* *
     * Possible implementation of wrap mode in shader code. Some modes are specialized by
     * filter.
     */
    enum class ShaderMode : uint16_t {
        kNone,                  // Using HW mode
        kClamp,                 // Shader based clamp, no filter specialization
        kRepeat_Nearest_None,   // Simple repeat for nearest sampling, no mipmapping
        kRepeat_Linear_None,    // Filter the subset boundary for kRepeat mode, no mip mapping
        kRepeat_Linear_Mipmap,  // Logic for linear filtering and LOD selection with kRepeat mode.
        kRepeat_Nearest_Mipmap, // Logic for nearest filtering and LOD selection with kRepeat mode.
        kMirrorRepeat,          // Mirror repeat (doesn't depend on filter))
        kClampToBorder_Nearest, // Logic for hard transition to border color when not filtering.
        kClampToBorder_Filter,  // Logic for fading to border color when filtering.
    };
    static ShaderMode GetShaderMode(GrSamplerState::WrapMode, GrSamplerState::Filter, GrSamplerState::MipmapMode);
    static bool ShaderModeIsClampToBorder(ShaderMode);
    // To keep things a little simpler, when we have filtering logic in the shader we
    // operate on unnormalized texture coordinates. We will add a uniform that stores
    // {1/w, 1/h} in a float2 and normalizes after the mode is handled if the texture
    // is not rectangle.
    static bool ShaderModeRequiresUnormCoord(ShaderMode);

    GrSurfaceProxyView fView;
    GrSamplerState fSamplerState;
    float fBorder[4];
    SkRect fSubset;
    SkRect fClamp;
    ShaderMode fShaderModes[2];

    inline GrTextureEffect(GrSurfaceProxyView, SkAlphaType, const Sampling &);

    explicit GrTextureEffect(const GrTextureEffect &src);

    std::unique_ptr<ProgramImpl> onMakeProgramImpl() const override;

    void onAddToKey(const GrShaderCaps &, skgpu::KeyBuilder *) const override;

    bool onIsEqual(const GrFragmentProcessor &) const override;

    bool matrixEffectShouldNormalize() const;

    bool hasClampToBorderShaderMode() const
    {
        return ShaderModeIsClampToBorder(fShaderModes[0]) || ShaderModeIsClampToBorder(fShaderModes[1]);
    }

    GR_DECLARE_FRAGMENT_PROCESSOR_TEST

    using INHERITED = GrFragmentProcessor;
};
#endif
